home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / weakref.pyo (.txt) < prev    next >
Python Compiled Bytecode  |  2008-10-13  |  10KB  |  377 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. import UserDict
  5. from _weakref import getweakrefcount, getweakrefs, ref, proxy, CallableProxyType, ProxyType, ReferenceType
  6. from exceptions import ReferenceError
  7. ProxyTypes = (ProxyType, CallableProxyType)
  8. __all__ = [
  9.     'ref',
  10.     'proxy',
  11.     'getweakrefcount',
  12.     'getweakrefs',
  13.     'WeakKeyDictionary',
  14.     'ReferenceType',
  15.     'ProxyType',
  16.     'CallableProxyType',
  17.     'ProxyTypes',
  18.     'WeakValueDictionary']
  19.  
  20. class WeakValueDictionary(UserDict.UserDict):
  21.     
  22.     def __init__(self, *args, **kw):
  23.         
  24.         def remove(wr, selfref = ref(self)):
  25.             self = selfref()
  26.             if self is not None:
  27.                 del self.data[wr.key]
  28.             
  29.  
  30.         self._remove = remove
  31.         UserDict.UserDict.__init__(self, *args, **kw)
  32.  
  33.     
  34.     def __getitem__(self, key):
  35.         o = self.data[key]()
  36.         if o is None:
  37.             raise KeyError, key
  38.         else:
  39.             return o
  40.  
  41.     
  42.     def __contains__(self, key):
  43.         
  44.         try:
  45.             o = self.data[key]()
  46.         except KeyError:
  47.             return False
  48.  
  49.         return o is not None
  50.  
  51.     
  52.     def has_key(self, key):
  53.         
  54.         try:
  55.             o = self.data[key]()
  56.         except KeyError:
  57.             return False
  58.  
  59.         return o is not None
  60.  
  61.     
  62.     def __repr__(self):
  63.         return '<WeakValueDictionary at %s>' % id(self)
  64.  
  65.     
  66.     def __setitem__(self, key, value):
  67.         self.data[key] = KeyedRef(value, self._remove, key)
  68.  
  69.     
  70.     def copy(self):
  71.         new = WeakValueDictionary()
  72.         for key, wr in self.data.items():
  73.             o = wr()
  74.             if o is not None:
  75.                 new[key] = o
  76.                 continue
  77.         
  78.         return new
  79.  
  80.     
  81.     def get(self, key, default = None):
  82.         
  83.         try:
  84.             wr = self.data[key]
  85.         except KeyError:
  86.             return default
  87.  
  88.         o = wr()
  89.         if o is None:
  90.             return default
  91.         else:
  92.             return o
  93.  
  94.     
  95.     def items(self):
  96.         L = []
  97.         for key, wr in self.data.items():
  98.             o = wr()
  99.             if o is not None:
  100.                 L.append((key, o))
  101.                 continue
  102.         
  103.         return L
  104.  
  105.     
  106.     def iteritems(self):
  107.         for wr in self.data.itervalues():
  108.             value = wr()
  109.             if value is not None:
  110.                 yield (wr.key, value)
  111.                 continue
  112.         
  113.  
  114.     
  115.     def iterkeys(self):
  116.         return self.data.iterkeys()
  117.  
  118.     
  119.     def __iter__(self):
  120.         return self.data.iterkeys()
  121.  
  122.     
  123.     def itervaluerefs(self):
  124.         return self.data.itervalues()
  125.  
  126.     
  127.     def itervalues(self):
  128.         for wr in self.data.itervalues():
  129.             obj = wr()
  130.             if obj is not None:
  131.                 yield obj
  132.                 continue
  133.         
  134.  
  135.     
  136.     def popitem(self):
  137.         while None:
  138.             (key, wr) = self.data.popitem()
  139.             o = wr()
  140.             if o is not None:
  141.                 return (key, o)
  142.                 continue
  143.             continue
  144.             return None
  145.  
  146.     
  147.     def pop(self, key, *args):
  148.         
  149.         try:
  150.             o = self.data.pop(key)()
  151.         except KeyError:
  152.             if args:
  153.                 return args[0]
  154.             
  155.             raise 
  156.  
  157.         if o is None:
  158.             raise KeyError, key
  159.         else:
  160.             return o
  161.  
  162.     
  163.     def setdefault(self, key, default = None):
  164.         
  165.         try:
  166.             wr = self.data[key]
  167.         except KeyError:
  168.             self.data[key] = KeyedRef(default, self._remove, key)
  169.             return default
  170.  
  171.         return wr()
  172.  
  173.     
  174.     def update(self, dict = None, **kwargs):
  175.         d = self.data
  176.         if dict is not None:
  177.             if not hasattr(dict, 'items'):
  178.                 dict = type({ })(dict)
  179.             
  180.             for key, o in dict.items():
  181.                 d[key] = KeyedRef(o, self._remove, key)
  182.             
  183.         
  184.         if len(kwargs):
  185.             self.update(kwargs)
  186.         
  187.  
  188.     
  189.     def valuerefs(self):
  190.         return self.data.values()
  191.  
  192.     
  193.     def values(self):
  194.         L = []
  195.         for wr in self.data.values():
  196.             o = wr()
  197.             if o is not None:
  198.                 L.append(o)
  199.                 continue
  200.         
  201.         return L
  202.  
  203.  
  204.  
  205. class KeyedRef(ref):
  206.     __slots__ = ('key',)
  207.     
  208.     def __new__(type, ob, callback, key):
  209.         self = ref.__new__(type, ob, callback)
  210.         self.key = key
  211.         return self
  212.  
  213.     
  214.     def __init__(self, ob, callback, key):
  215.         super(KeyedRef, self).__init__(ob, callback)
  216.  
  217.  
  218.  
  219. class WeakKeyDictionary(UserDict.UserDict):
  220.     
  221.     def __init__(self, dict = None):
  222.         self.data = { }
  223.         
  224.         def remove(k, selfref = ref(self)):
  225.             self = selfref()
  226.             if self is not None:
  227.                 del self.data[k]
  228.             
  229.  
  230.         self._remove = remove
  231.         if dict is not None:
  232.             self.update(dict)
  233.         
  234.  
  235.     
  236.     def __delitem__(self, key):
  237.         del self.data[ref(key)]
  238.  
  239.     
  240.     def __getitem__(self, key):
  241.         return self.data[ref(key)]
  242.  
  243.     
  244.     def __repr__(self):
  245.         return '<WeakKeyDictionary at %s>' % id(self)
  246.  
  247.     
  248.     def __setitem__(self, key, value):
  249.         self.data[ref(key, self._remove)] = value
  250.  
  251.     
  252.     def copy(self):
  253.         new = WeakKeyDictionary()
  254.         for key, value in self.data.items():
  255.             o = key()
  256.             if o is not None:
  257.                 new[o] = value
  258.                 continue
  259.         
  260.         return new
  261.  
  262.     
  263.     def get(self, key, default = None):
  264.         return self.data.get(ref(key), default)
  265.  
  266.     
  267.     def has_key(self, key):
  268.         
  269.         try:
  270.             wr = ref(key)
  271.         except TypeError:
  272.             return 0
  273.  
  274.         return wr in self.data
  275.  
  276.     
  277.     def __contains__(self, key):
  278.         
  279.         try:
  280.             wr = ref(key)
  281.         except TypeError:
  282.             return 0
  283.  
  284.         return wr in self.data
  285.  
  286.     
  287.     def items(self):
  288.         L = []
  289.         for key, value in self.data.items():
  290.             o = key()
  291.             if o is not None:
  292.                 L.append((o, value))
  293.                 continue
  294.         
  295.         return L
  296.  
  297.     
  298.     def iteritems(self):
  299.         for wr, value in self.data.iteritems():
  300.             key = wr()
  301.             if key is not None:
  302.                 yield (key, value)
  303.                 continue
  304.         
  305.  
  306.     
  307.     def iterkeyrefs(self):
  308.         return self.data.iterkeys()
  309.  
  310.     
  311.     def iterkeys(self):
  312.         for wr in self.data.iterkeys():
  313.             obj = wr()
  314.             if obj is not None:
  315.                 yield obj
  316.                 continue
  317.         
  318.  
  319.     
  320.     def __iter__(self):
  321.         return self.iterkeys()
  322.  
  323.     
  324.     def itervalues(self):
  325.         return self.data.itervalues()
  326.  
  327.     
  328.     def keyrefs(self):
  329.         return self.data.keys()
  330.  
  331.     
  332.     def keys(self):
  333.         L = []
  334.         for wr in self.data.keys():
  335.             o = wr()
  336.             if o is not None:
  337.                 L.append(o)
  338.                 continue
  339.         
  340.         return L
  341.  
  342.     
  343.     def popitem(self):
  344.         while None:
  345.             (key, value) = self.data.popitem()
  346.             o = key()
  347.             if o is not None:
  348.                 return (o, value)
  349.                 continue
  350.             continue
  351.             return None
  352.  
  353.     
  354.     def pop(self, key, *args):
  355.         return self.data.pop(ref(key), *args)
  356.  
  357.     
  358.     def setdefault(self, key, default = None):
  359.         return self.data.setdefault(ref(key, self._remove), default)
  360.  
  361.     
  362.     def update(self, dict = None, **kwargs):
  363.         d = self.data
  364.         if dict is not None:
  365.             if not hasattr(dict, 'items'):
  366.                 dict = type({ })(dict)
  367.             
  368.             for key, value in dict.items():
  369.                 d[ref(key, self._remove)] = value
  370.             
  371.         
  372.         if len(kwargs):
  373.             self.update(kwargs)
  374.         
  375.  
  376.  
  377.